home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / util / gnu / groff_src.lha / Groff-1.07 / troff / div.cc < prev    next >
C/C++ Source or Header  |  1992-10-29  |  27KB  |  1,110 lines
  1. // -*- C++ -*-
  2. /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
  3.      Written by James Clark (jjc@jclark.com)
  4.  
  5. This file is part of groff.
  6.  
  7. groff is free software; you can redistribute it and/or modify it under
  8. the terms of the GNU General Public License as published by the Free
  9. Software Foundation; either version 2, or (at your option) any later
  10. version.
  11.  
  12. groff is distributed in the hope that it will be useful, but WITHOUT ANY
  13. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License along
  18. with groff; see the file COPYING.  If not, write to the Free Software
  19. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21.  
  22. // diversions
  23.  
  24. #include "troff.h"
  25. #include "symbol.h"
  26. #include "dictionary.h"
  27. #include "hvunits.h"
  28. #include "env.h"
  29. #include "request.h"
  30. #include "node.h"
  31. #include "token.h"
  32. #include "div.h"
  33. #include "reg.h"
  34.  
  35. int exit_started = 0;        // the exit process has started
  36. int done_end_macro = 0;        // the end macro (if any) has finished
  37. int seen_last_page_ejector = 0;    // seen the LAST_PAGE_EJECTOR cookie
  38. static int began_page_in_end_macro = 0;    // a new page was begun during the end macro
  39.  
  40. static int last_post_line_extra_space = 0; // needed for \n(.a
  41. static int nl_reg_contents = -1;
  42. static int dl_reg_contents = 0;
  43. static int dn_reg_contents = 0;
  44. static int vertical_position_traps_flag = 1;
  45. static vunits truncated_space;
  46. static vunits needed_space;
  47.  
  48. diversion::diversion(symbol s) 
  49. : nm(s), prev(0), vertical_position(V0), marked_place(V0), high_water_mark(V0)
  50. {
  51. }
  52.  
  53. struct vertical_size {
  54.   vunits pre_extra, post_extra, pre, post;
  55.   vertical_size(vunits vs, int ls);
  56. };
  57.  
  58. vertical_size::vertical_size(vunits vs, int ls)
  59. : pre_extra(V0), post_extra(V0), pre(vs)
  60. {
  61.   if (ls > 1)
  62.     post = vs*(ls - 1);
  63.   else
  64.     post = V0;
  65. }
  66.  
  67. void node::set_vertical_size(vertical_size *)
  68. {
  69. }
  70.  
  71. void extra_size_node::set_vertical_size(vertical_size *v)
  72. {
  73.   if (n < V0) {
  74.     if (-n > v->pre_extra)
  75.       v->pre_extra = -n;
  76.   }
  77.   else if (n > v->post_extra)
  78.     v->post_extra = n;
  79. }
  80.  
  81. void vertical_size_node::set_vertical_size(vertical_size *v)
  82. {
  83.   if (n < V0)
  84.     v->pre = -n;
  85.   else
  86.     v->post = n;
  87. }
  88.  
  89. top_level_diversion *topdiv;
  90.  
  91. diversion *curdiv;
  92.  
  93. void do_divert(int append)
  94. {
  95.   tok.skip();
  96.   symbol nm = get_name();
  97.   if (nm.is_null()) {
  98.     if (curdiv->prev) {
  99.       diversion *temp = curdiv;
  100.       curdiv = curdiv->prev;
  101.       delete temp;
  102.     }
  103.     else
  104.       warning(WARN_DI, "diversion stack underflow");
  105.   }
  106.   else {
  107.     macro_diversion *md = new macro_diversion(nm, append);
  108.     md->prev = curdiv;
  109.     curdiv = md;
  110.   }
  111.   skip_line();
  112. }
  113.  
  114. void divert()
  115. {
  116.   do_divert(0);
  117. }
  118.  
  119. void divert_append()
  120. {
  121.   do_divert(1);
  122. }
  123.   
  124. void diversion::need(vunits n)
  125. {
  126.   vunits d = distance_to_next_trap();
  127.   if (d < n) {
  128.     space(d, 1);
  129.     truncated_space = -d;
  130.     needed_space = n;
  131.   }
  132. }
  133.  
  134. macro_diversion::macro_diversion(symbol s, int append)
  135. : diversion(s), max_width(H0)
  136. {
  137. #if 0
  138.   if (append) {
  139.     /* We don't allow recursive appends eg:
  140.  
  141.       .da a
  142.       .a
  143.       .di
  144.       
  145.       This causes an infinite loop in troff anyway.
  146.       This is because the user could do
  147.  
  148.       .as a foo
  149.  
  150.       in the diversion, and this would mess things up royally,
  151.       since there would be two things appending to the same
  152.       macro_header.
  153.       To make it work, we would have to copy the _contents_
  154.       of the macro into which we were diverting; this doesn't
  155.       strike me as worthwhile.
  156.       However,
  157.  
  158.       .di a
  159.       .a
  160.       .a
  161.       .di
  162.  
  163.        will work and will make `a' contain two copies of what it contained
  164.        before; in troff, `a' would contain nothing. */
  165.     request_or_macro *rm 
  166.       = (request_or_macro *)request_dictionary.remove(s);
  167.     if (!rm || (mac = rm->to_macro()) == 0)
  168.       mac = new macro;
  169.   }
  170.   else
  171.     mac = new macro;
  172. #endif
  173.   // We can now catch the situation described above by comparing
  174.   // the length of the charlist in the macro_header with the length
  175.   // stored in the macro. When we detect this, we copy the contents.
  176.   mac = new macro;
  177.   if (append) {
  178.     request_or_macro *rm 
  179.       = (request_or_macro *)request_dictionary.lookup(s);
  180.     if (rm) {
  181.       macro *m = rm->to_macro();
  182.       if (m)
  183.     *mac = *m;
  184.     }
  185.   }
  186. }
  187.  
  188. macro_diversion::~macro_diversion()
  189. {
  190.   request_or_macro *rm = (request_or_macro *)request_dictionary.lookup(nm);
  191.   macro *m = rm ? rm->to_macro() : 0;
  192.   if (m) {
  193.     *m = *mac;
  194.     delete mac;
  195.   }
  196.   else
  197.     request_dictionary.define(nm, mac);
  198.   mac = 0;
  199.   dl_reg_contents = max_width.to_units();
  200.   dn_reg_contents = vertical_position.to_units();
  201. }
  202.  
  203. vunits macro_diversion::distance_to_next_trap()
  204. {
  205.   if (!diversion_trap.is_null() && diversion_trap_pos > vertical_position)
  206.     return diversion_trap_pos - vertical_position;
  207.   else
  208.     // Substract vresolution so that vunits::vunits does not overflow.
  209.     return vunits(INT_MAX - vresolution);
  210. }
  211.  
  212. void macro_diversion::transparent_output(unsigned char c)
  213. {
  214.   mac->append(c);
  215. }
  216.  
  217. void macro_diversion::transparent_output(node *n)
  218. {
  219.   mac->append(n);
  220. }
  221.  
  222. void macro_diversion::output(node *nd, int retain_size,
  223.                  vunits vs, int ls, hunits width)
  224. {
  225.   vertical_size v(vs, ls);
  226.   while (nd != 0) {
  227.     nd->set_vertical_size(&v);
  228.     node *temp = nd;
  229.     nd = nd->next;
  230.     if (temp->interpret(mac)) {
  231.       delete temp;
  232.     }
  233.     else {
  234. #if 1
  235.       temp->freeze_space();
  236. #endif
  237.       mac->append(temp);
  238.     }
  239.   }
  240.   if (!v.post_extra.is_zero())
  241.     last_post_line_extra_space = v.post_extra.to_units();
  242.   if (!retain_size) {
  243.     v.pre = vs;
  244.     v.post = (ls > 1) ? vs*(ls - 1) : V0;
  245.   }
  246.   if (width > max_width)
  247.     max_width = width;
  248.   vunits x = v.pre + v.pre_extra + v.post + v.post_extra;
  249.   if (vertical_position_traps_flag
  250.       && !diversion_trap.is_null() && diversion_trap_pos > vertical_position
  251.       && diversion_trap_pos <= vertical_position + x) {
  252.     vunits trunc = vertical_position + x - diversion_trap_pos;
  253.     if (trunc > v.post)
  254.       trunc = v.post;
  255.     v.post -= trunc;
  256.     x -= trunc;
  257.     truncated_space = trunc;
  258.     spring_trap(diversion_trap);
  259.   }
  260.   mac->append(new vertical_size_node(-v.pre));
  261.   mac->append(new vertical_size_node(v.post));
  262.   mac->append('\n');
  263.   vertical_position += x;
  264.   if (vertical_position > high_water_mark)
  265.     high_water_mark = vertical_position;
  266. }
  267.  
  268. void macro_diversion::space(vunits n, int)
  269. {
  270.   if (vertical_position_traps_flag
  271.       && !diversion_trap.is_null() && diversion_trap_pos > vertical_position
  272.       && diversion_trap_pos <= vertical_position + n) {
  273.     truncated_space = vertical_position + n - diversion_trap_pos;
  274.     n = diversion_trap_pos - vertical_position;
  275.     spring_trap(diversion_trap);
  276.   }
  277.   else if (n + vertical_position < V0)
  278.     n = -vertical_position;
  279.   mac->append(new diverted_space_node(n));
  280.   vertical_position += n;
  281.   if (vertical_position > high_water_mark)
  282.     high_water_mark = vertical_position;
  283. }
  284.  
  285. void macro_diversion::copy_file(const char *filename)
  286. {
  287.   mac->append(new diverted_copy_file_node(filename));
  288. }
  289.  
  290. top_level_diversion::top_level_diversion()
  291. : page_count(0), have_next_page_number(0), page_length(units_per_inch*11), 
  292.   page_offset(units_per_inch), prev_page_offset(units_per_inch), 
  293.   ejecting_page(0), page_trap_list(0), first_page_begun(0), no_space_mode(0),
  294.   page_number(0), last_page_count(-1)
  295. {
  296. }
  297.  
  298. // find the next trap after pos
  299.  
  300. trap *top_level_diversion::find_next_trap(vunits *next_trap_pos)
  301. {
  302.   trap *next_trap = 0;
  303.   for (trap *pt = page_trap_list; pt != 0; pt = pt->next)
  304.     if (!pt->nm.is_null()) {
  305.       if (pt->position >= V0) {
  306.     if (pt->position > vertical_position 
  307.         && pt->position < page_length
  308.         && (next_trap == 0 || pt->position < *next_trap_pos)) {
  309.           next_trap = pt;
  310.           *next_trap_pos = pt->position;
  311.         }
  312.       }
  313.       else {
  314.     vunits pos = pt->position;
  315.     pos += page_length;
  316.     if (pos > 0 && pos > vertical_position && (next_trap == 0 || pos < *next_trap_pos)) {
  317.       next_trap = pt;
  318.       *next_trap_pos = pos;
  319.     }
  320.       }
  321.     }
  322.   return next_trap;
  323. }
  324.  
  325. vunits top_level_diversion::distance_to_next_trap()
  326. {
  327.   vunits d;
  328.   if (!find_next_trap(&d))
  329.     return page_length - vertical_position;
  330.   else
  331.     return d - vertical_position;
  332. }
  333.  
  334. void top_level_diversion::output(node *nd, int retain_size,
  335.                  vunits vs, int ls, hunits /*width*/)
  336. {
  337.   no_space_mode = 0;
  338.   vunits next_trap_pos;
  339.   trap *next_trap = find_next_trap(&next_trap_pos);
  340.   if (!first_page_begun && begin_page()) 
  341.     fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request");
  342.   vertical_size v(vs, ls);
  343.   for (node *tem = nd; tem != 0; tem = tem->next)
  344.     tem->set_vertical_size(&v);
  345.   if (!v.post_extra.is_zero())
  346.     last_post_line_extra_space = v.post_extra.to_units();
  347.   if (!retain_size) {
  348.     v.pre = vs;
  349.     v.post = (ls > 1) ? vs*(ls - 1) : V0;
  350.   }
  351.   vertical_position += v.pre;
  352.   vertical_position += v.pre_extra;
  353.   the_output->print_line(page_offset, vertical_position, nd,
  354.              v.pre + v.pre_extra, v.post_extra);
  355.   vertical_position += v.post_extra;
  356.   if (vertical_position_traps_flag && vertical_position >= page_length)
  357.     begin_page();
  358.   else if (vertical_position_traps_flag
  359.        && next_trap != 0 && vertical_position >= next_trap_pos) {
  360.     nl_reg_contents = vertical_position.to_units();
  361.     truncated_space = v.post;
  362.     if (vertical_position > high_water_mark)
  363.       high_water_mark = vertical_position;
  364.     spring_trap(next_trap->nm);
  365.   }
  366.   else if (v.post > V0) {
  367.     vertical_position += v.post;
  368.     if (vertical_position_traps_flag
  369.     && next_trap != 0 && vertical_position >= next_trap_pos) {
  370.       truncated_space = vertical_position - next_trap_pos;
  371.       vertical_position = next_trap_pos;
  372.       nl_reg_contents = vertical_position.to_units();
  373.       if (vertical_position > high_water_mark)
  374.     high_water_mark = vertical_position;
  375.       spring_trap(next_trap->nm);
  376.     }
  377.     else if (vertical_position_traps_flag && vertical_position >= page_length)
  378.       begin_page();
  379.     else {
  380.       nl_reg_contents = vertical_position.to_units();
  381.       if (vertical_position > high_water_mark)
  382.     high_water_mark = vertical_position;
  383.     }
  384.   }
  385.   else {
  386.     nl_reg_contents = vertical_position.to_units();
  387.     if (vertical_position > high_water_mark)
  388.       high_water_mark = vertical_position;
  389.   }
  390. }
  391.  
  392. void top_level_diversion::transparent_output(unsigned char c)
  393. {
  394.   if (!first_page_begun && begin_page())
  395.     // This can only happen with the transparent() request.
  396.     fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request");
  397.   const char *s = asciify(c);
  398.   while (*s)
  399.     the_output->transparent_char(*s++);
  400. }
  401.  
  402. void top_level_diversion::transparent_output(node * /*n*/)
  403. {
  404.   error("can't transparently output node at top level");
  405. }
  406.  
  407. void top_level_diversion::copy_file(const char *filename)
  408. {
  409.   if (!first_page_begun && begin_page())
  410.     fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request");
  411.   the_output->copy_file(page_offset, vertical_position, filename);
  412. }
  413.  
  414. void top_level_diversion::space(vunits n, int forced)
  415. {
  416.   if (no_space_mode) {
  417.     if (!forced)
  418.       return;
  419.     else
  420.       no_space_mode = 0;
  421.   }
  422.   if (!first_page_begun) {
  423.     if (begin_page()) {
  424.       // This happens if there's a top of page trap, and the first-page
  425.       // transition is caused by `'sp'.
  426.       truncated_space = n > V0 ? n : V0;
  427.       return;
  428.     }
  429.   }
  430.   vunits next_trap_pos;
  431.   trap *next_trap = find_next_trap(&next_trap_pos);
  432.   vunits y = vertical_position + n;
  433.   if (vertical_position_traps_flag && next_trap != 0 && y >= next_trap_pos) {
  434.     vertical_position = next_trap_pos;
  435.     nl_reg_contents = vertical_position.to_units();
  436.     truncated_space = y - vertical_position;
  437.     if (vertical_position > high_water_mark)
  438.       high_water_mark = vertical_position;
  439.     spring_trap(next_trap->nm);
  440.   }
  441.   else if (y < V0) {
  442.     vertical_position = V0;
  443.     nl_reg_contents = vertical_position.to_units();
  444.   }
  445.   else if (vertical_position_traps_flag && y >= page_length && n >= V0)
  446.     begin_page();
  447.   else {
  448.     vertical_position = y;
  449.     nl_reg_contents = vertical_position.to_units();
  450.     if (vertical_position > high_water_mark)
  451.       high_water_mark = vertical_position;
  452.   }
  453. }
  454.  
  455. trap::trap(symbol s, vunits n, trap *p)
  456.      : nm(s), next(p), position(n)
  457. {
  458. }
  459.  
  460. void top_level_diversion::add_trap(symbol nm, vunits pos)
  461. {
  462.   trap *first_free_slot = 0;
  463.   for (trap **p = &page_trap_list; *p; p = &(*p)->next) {
  464.     if ((*p)->nm.is_null()) {
  465.       if (first_free_slot == 0)
  466.     first_free_slot = *p;
  467.     }
  468.     else if ((*p)->position == pos) {
  469.       (*p)->nm = nm;
  470.       return;
  471.     }
  472.   }
  473.   if (first_free_slot) {
  474.     first_free_slot->nm = nm;
  475.     first_free_slot->position = pos;
  476.   }
  477.   else
  478.     *p = new trap(nm, pos, 0);
  479. }  
  480.  
  481. void top_level_diversion::remove_trap(symbol nm)
  482. {
  483.   for (trap *p = page_trap_list; p; p = p->next)
  484.     if (p->nm == nm) {
  485.       p->nm = NULL_SYMBOL;
  486.       return;
  487.     }
  488. }
  489.  
  490. void top_level_diversion::remove_trap_at(vunits pos)
  491. {
  492.   for (trap *p = page_trap_list; p; p = p->next)
  493.     if (p->position == pos) {
  494.       p->nm = NULL_SYMBOL;
  495.       return;
  496.     }
  497. }
  498.       
  499. void top_level_diversion::change_trap(symbol nm, vunits pos)
  500. {
  501.   for (trap *p = page_trap_list; p; p = p->next)
  502.     if (p->nm == nm) {
  503.       p->position = pos;
  504.       return;
  505.     }
  506. }
  507.  
  508. void top_level_diversion::print_traps()
  509. {
  510.   for (trap *p = page_trap_list; p; p = p->next)
  511.     if (p->nm.is_null())
  512.       fprintf(stderr, "  empty\n");
  513.     else
  514.       fprintf(stderr, "%s\t%d\n", p->nm.contents(), p->position.to_units());
  515.   fflush(stderr);
  516. }
  517.  
  518. void end_diversions()
  519. {
  520.   while (curdiv != topdiv) {
  521.     error("automatically ending diversion `%1' on exit",
  522.         curdiv->nm.contents());
  523.     diversion *tem = curdiv;
  524.     curdiv = curdiv->prev;
  525.     delete tem;
  526.   }
  527. }
  528.  
  529. NO_RETURN void cleanup_and_exit(int exit_code)
  530. {
  531.   if (the_output)
  532.     delete the_output;
  533.   exit(exit_code);
  534. }
  535.  
  536. // returns non-zero if it sprung a top of page trap
  537.  
  538. int top_level_diversion::begin_page()
  539. {
  540.   if (exit_started) {
  541.     if (page_count == last_page_count
  542.     ? curenv->is_empty()
  543.     : (done_end_macro && (seen_last_page_ejector || began_page_in_end_macro)))
  544.       cleanup_and_exit(0);
  545.     if (!done_end_macro)
  546.       began_page_in_end_macro = 1;
  547.   }
  548.   if (!the_output)
  549.     init_output();
  550.   ++page_count;
  551.   if (have_next_page_number) {
  552.     page_number = next_page_number;
  553.     have_next_page_number = 0;
  554.   }
  555.   else if (!first_page_begun)
  556.     page_number = 1;
  557.   else
  558.     page_number++;
  559.   // spring the top of page trap if there is one
  560.   vunits next_trap_pos;
  561.   vertical_position = -vresolution;
  562.   trap *next_trap = find_next_trap(&next_trap_pos);
  563.   vertical_position = V0;
  564.   high_water_mark = V0;
  565.   first_page_begun = 1;
  566.   ejecting_page = 0;
  567.   the_output->begin_page(page_number, page_length);
  568.   nl_reg_contents = vertical_position.to_units();
  569.   if (vertical_position_traps_flag && next_trap != 0 && next_trap_pos == V0) {
  570.     truncated_space = V0;
  571.     spring_trap(next_trap->nm);
  572.     return 1;
  573.   }
  574.   else
  575.     return 0;
  576. }
  577.  
  578. void continue_page_eject()
  579. {
  580.   if (topdiv->get_ejecting()) {
  581.     if (curdiv != topdiv)
  582.       error("can't continue page ejection because of current diversion");
  583.     else if (!vertical_position_traps_flag)
  584.       error("can't continue page ejection because vertical position traps disabled");
  585.     else {
  586.       push_page_ejector();
  587.       topdiv->space(topdiv->get_page_length(), 1);
  588.     }
  589.   }
  590. }
  591.  
  592. void top_level_diversion::set_next_page_number(int n)
  593. {
  594.   next_page_number= n;
  595.   have_next_page_number = 1;
  596. }
  597.  
  598. int top_level_diversion::get_next_page_number()
  599. {
  600.   return have_next_page_number ? next_page_number : page_number + 1;
  601. }
  602.  
  603. void top_level_diversion::set_page_length(vunits n)
  604. {
  605.   page_length = n;
  606. }
  607.  
  608. diversion::~diversion()
  609. {
  610. }
  611.  
  612. void page_offset()
  613. {
  614.   hunits n;
  615.   if (!has_arg() || !get_hunits(&n, 'v', topdiv->page_offset))
  616.     n = topdiv->prev_page_offset;
  617.   topdiv->prev_page_offset = topdiv->page_offset;
  618.   topdiv->page_offset = n;
  619.   skip_line();
  620. }
  621.  
  622. void page_length()
  623. {
  624.   vunits n;
  625.   if (has_arg() && get_vunits(&n, 'v', topdiv->get_page_length()))
  626.     topdiv->set_page_length(n);
  627.   else
  628.     topdiv->set_page_length(11*units_per_inch);
  629.   skip_line();
  630. }
  631.  
  632. void when_request()
  633. {
  634.   vunits n;
  635.   if (get_vunits(&n, 'v')) {
  636.     symbol s = get_name();
  637.     if (s.is_null())
  638.       topdiv->remove_trap_at(n);
  639.     else
  640.       topdiv->add_trap(s, n);
  641.   }
  642.   skip_line();
  643. }
  644.  
  645. void begin_page()
  646. {
  647.   int got_arg = 0;
  648.   int n;
  649.   if (has_arg() && get_integer(&n, topdiv->get_page_number()))
  650.     got_arg = 1;
  651.   while (!tok.newline() && !tok.eof())
  652.     tok.next();
  653.   if (curdiv == topdiv) {
  654.     if (!topdiv->first_page_begun) {
  655.       if (!break_flag) {
  656.     if (got_arg)
  657.       topdiv->set_next_page_number(n);
  658.     if (got_arg || !topdiv->no_space_mode)
  659.       topdiv->begin_page();
  660.       }
  661.       else if (topdiv->no_space_mode && !got_arg)
  662.     topdiv->begin_page();
  663.       else {
  664.     /* Given this
  665.  
  666.          .wh 0 x
  667.      .de x
  668.      .tm \\n%
  669.      ..
  670.      .bp 3
  671.  
  672.      troff prints
  673.  
  674.      1
  675.      3
  676.  
  677.      This code makes groff do the same. */
  678.  
  679.     push_page_ejector();
  680.     topdiv->begin_page();
  681.     if (got_arg)
  682.       topdiv->set_next_page_number(n);
  683.     topdiv->set_ejecting();
  684.       }
  685.     }
  686.     else {
  687.       push_page_ejector();
  688.       if (break_flag)
  689.     curenv->do_break();
  690.       if (got_arg)
  691.     topdiv->set_next_page_number(n);
  692.       if (!(topdiv->no_space_mode && !got_arg))
  693.     topdiv->set_ejecting();
  694.     }
  695.   }
  696.   tok.next();
  697. }
  698.  
  699. void no_space()
  700. {
  701.   if (curdiv == topdiv)
  702.     topdiv->no_space_mode = 1;
  703.   skip_line();
  704. }
  705.  
  706. void restore_spacing()
  707. {
  708.   if (curdiv == topdiv)
  709.     topdiv->no_space_mode = 0;
  710.   skip_line();
  711. }
  712.  
  713. /* It is necessary to generate a break before before reading the argument,
  714. because otherwise arguments using | will be wrong. But if we just
  715. generate a break as usual, then the line forced out may spring a trap
  716. and thus push a macro onto the input stack before we have had a chance
  717. to read the argument to the sp request. We resolve this dilemma by
  718. setting, before generating the break, a flag which will postpone the
  719. actual pushing of the macro associated with the trap sprung by the
  720. outputting of the line forced out by the break till after we have read
  721. the argument to the request.  If the break did cause a trap to be
  722. sprung, then we don't actually do the space. */
  723.  
  724. void space_request()
  725. {
  726.   postpone_traps();
  727.   if (break_flag)
  728.     curenv->do_break();
  729.   vunits n;
  730.   if (!has_arg() || !get_vunits(&n, 'v'))
  731.     n = curenv->get_vertical_spacing();
  732.   while (!tok.newline() && !tok.eof())
  733.     tok.next();
  734.   if (!unpostpone_traps())
  735.     curdiv->space(n);
  736.   else
  737.     // The line might have had line spacing that was truncated.
  738.     truncated_space += n;
  739.   tok.next();
  740. }
  741.  
  742. void blank_line()
  743. {
  744.   curenv->do_break();
  745.   if (!trap_sprung_flag)
  746.     curdiv->space(curenv->get_vertical_spacing());
  747.   else
  748.     truncated_space += curenv->get_vertical_spacing();
  749. }
  750.  
  751. /* need_space might spring a trap and so we must be careful that the
  752. BEGIN_TRAP token is not skipped over. */
  753.  
  754. void need_space()
  755. {
  756.   vunits n;
  757.   if (!has_arg() || !get_vunits(&n, 'v'))
  758.     n = curenv->get_vertical_spacing();
  759.   while (!tok.newline() && !tok.eof())
  760.     tok.next();
  761.   curdiv->need(n);
  762.   tok.next();
  763. }
  764.  
  765. void page_number()
  766. {
  767.   int n;
  768.   if (has_arg() && get_integer(&n, topdiv->get_page_number()))
  769.     topdiv->set_next_page_number(n);
  770.   skip_line();
  771. }
  772.  
  773. vunits saved_space;
  774.  
  775. void save_vertical_space()
  776. {
  777.   vunits x;
  778.   if (get_vunits(&x, 'v')) {
  779.     if (curdiv->distance_to_next_trap() > x)
  780.       curdiv->space(x, 1);
  781.     else
  782.       saved_space = x;
  783.   }
  784.   skip_line();
  785. }
  786.  
  787. void output_saved_vertical_space()
  788. {
  789.   while (!tok.newline() && !tok.eof())
  790.     tok.next();
  791.   if (saved_space > V0)
  792.     curdiv->space(saved_space, 1);
  793.   saved_space = V0;
  794.   tok.next();
  795. }
  796.  
  797. void flush_output()
  798. {
  799.   while (!tok.newline() && !tok.eof())
  800.     tok.next();
  801.   if (break_flag)
  802.     curenv->do_break();
  803.   if (the_output)
  804.     the_output->flush();
  805.   tok.next();
  806. }
  807.  
  808. void macro_diversion::set_diversion_trap(symbol s, vunits n)
  809. {
  810.   diversion_trap = s;
  811.   diversion_trap_pos = n;
  812. }
  813.  
  814. void macro_diversion::clear_diversion_trap()
  815. {
  816.   diversion_trap = NULL_SYMBOL;
  817. }
  818.  
  819. void top_level_diversion::set_diversion_trap(symbol, vunits)
  820. {
  821.   error("can't set diversion trap when no current diversion");
  822. }
  823.  
  824. void top_level_diversion::clear_diversion_trap()
  825. {
  826.   error("can't set diversion trap when no current diversion");
  827. }
  828.  
  829. void diversion_trap()
  830. {
  831.   vunits n;
  832.   if (has_arg() && get_vunits(&n, 'v')) {
  833.     symbol s = get_name();
  834.     if (!s.is_null())
  835.       curdiv->set_diversion_trap(s, n);
  836.     else
  837.       curdiv->clear_diversion_trap();
  838.   }
  839.   else
  840.     curdiv->clear_diversion_trap();
  841.   skip_line();
  842. }
  843.  
  844. void change_trap()
  845. {
  846.   symbol s = get_name(1);
  847.   if (!s.is_null()) {
  848.     vunits x;
  849.     if (has_arg() && get_vunits(&x, 'v'))
  850.       topdiv->change_trap(s, x);
  851.     else
  852.       topdiv->remove_trap(s);
  853.   }
  854.   skip_line();
  855. }
  856.  
  857. void print_traps()
  858. {
  859.   topdiv->print_traps();
  860.   skip_line();
  861. }
  862.  
  863. void mark()
  864. {
  865.   symbol s = get_name();
  866.   if (s.is_null())
  867.     curdiv->marked_place = curdiv->get_vertical_position();
  868.   else if (curdiv == topdiv)
  869.     set_number_reg(s, nl_reg_contents);
  870.   else
  871.     set_number_reg(s, curdiv->get_vertical_position().to_units());
  872.   skip_line();
  873. }
  874.  
  875. // This is truly bizarre.  It is documented in the SQ manual.
  876.  
  877. void return_request()
  878. {
  879.   vunits dist = curdiv->marked_place - curdiv->get_vertical_position();
  880.   if (has_arg()) {
  881.     if (tok.ch() == '-') {
  882.       tok.next();
  883.       vunits x;
  884.       if (get_vunits(&x, 'v'))
  885.     dist = -x;
  886.     }
  887.     else {
  888.       vunits x;
  889.       if (get_vunits(&x, 'v'))
  890.     dist = x >= V0 ? x - curdiv->get_vertical_position() : V0;
  891.     }
  892.   }
  893.   if (dist < V0)
  894.     curdiv->space(dist);
  895.   skip_line();
  896. }
  897.  
  898. void vertical_position_traps()
  899. {
  900.   int n;
  901.   if (has_arg() && get_integer(&n))
  902.     vertical_position_traps_flag = (n != 0);
  903.   else
  904.     vertical_position_traps_flag = 1;
  905.   skip_line();
  906. }
  907.  
  908. class page_offset_reg : public reg {
  909. public:
  910.   int get_value(units *);
  911.   const char *get_string();
  912. };
  913.   
  914. int page_offset_reg::get_value(units *res)
  915. {
  916.   *res = topdiv->get_page_offset().to_units();
  917.   return 1;
  918. }
  919.  
  920. const char *page_offset_reg::get_string()
  921. {
  922.   return itoa(topdiv->get_page_offset().to_units());
  923. }
  924.  
  925. class page_length_reg : public reg {
  926. public:
  927.   int get_value(units *);
  928.   const char *get_string();
  929. };
  930.   
  931. int page_length_reg::get_value(units *res)
  932. {
  933.   *res = topdiv->get_page_length().to_units();
  934.   return 1;
  935. }
  936.  
  937. const char *page_length_reg::get_string()
  938. {
  939.   return itoa(topdiv->get_page_length().to_units());
  940. }
  941.  
  942. class vertical_position_reg : public reg {
  943. public:
  944.   int get_value(units *);
  945.   const char *get_string();
  946. };
  947.   
  948. int vertical_position_reg::get_value(units *res)
  949. {
  950.   if (curdiv == topdiv && !topdiv->first_page_begun)
  951.     *res = -1;
  952.   else
  953.     *res = curdiv->get_vertical_position().to_units();
  954.   return 1;
  955. }
  956.  
  957. const char *vertical_position_reg::get_string()
  958. {
  959.   if (curdiv == topdiv && !topdiv->first_page_begun)
  960.     return "-1";
  961.   else
  962.     return itoa(curdiv->get_vertical_position().to_units());
  963. }
  964.  
  965. class high_water_mark_reg : public reg {
  966. public:
  967.   int get_value(units *);
  968.   const char *get_string();
  969. };
  970.   
  971. int high_water_mark_reg::get_value(units *res)
  972. {
  973.   *res = curdiv->get_high_water_mark().to_units();
  974.   return 1;
  975. }
  976.  
  977. const char *high_water_mark_reg::get_string()
  978. {
  979.   return itoa(curdiv->get_high_water_mark().to_units());
  980. }
  981.  
  982. class distance_to_next_trap_reg : public reg {
  983. public:
  984.   int get_value(units *);
  985.   const char *get_string();
  986. };
  987.   
  988. int distance_to_next_trap_reg::get_value(units *res)
  989. {
  990.   *res = curdiv->distance_to_next_trap().to_units();
  991.   return 1;
  992. }
  993.  
  994. const char *distance_to_next_trap_reg::get_string()
  995. {
  996.   return itoa(curdiv->distance_to_next_trap().to_units());
  997. }
  998.  
  999. class diversion_name_reg : public reg {
  1000. public:
  1001.   const char *get_string();
  1002. };
  1003.  
  1004. const char *diversion_name_reg::get_string()
  1005. {
  1006.   return curdiv->get_diversion_name();
  1007. }
  1008.  
  1009. class page_number_reg : public general_reg {
  1010. public:
  1011.   page_number_reg();
  1012.   int get_value(units *);
  1013.   void set_value(units);
  1014. };
  1015.  
  1016. page_number_reg::page_number_reg()
  1017. {
  1018. }
  1019.  
  1020. void page_number_reg::set_value(units n)
  1021. {
  1022.   topdiv->set_page_number(n);
  1023. }
  1024.  
  1025. int page_number_reg::get_value(units *res)
  1026. {
  1027.   *res = topdiv->get_page_number();
  1028.   return 1;
  1029. }
  1030.  
  1031. class next_page_number_reg : public reg {
  1032. public:
  1033.   const char *get_string();
  1034. };
  1035.  
  1036. const char *next_page_number_reg::get_string()
  1037. {
  1038.   return itoa(topdiv->get_next_page_number());
  1039. }
  1040.  
  1041. class page_ejecting_reg : public reg {
  1042. public:
  1043.   const char *get_string();
  1044. };
  1045.  
  1046. const char *page_ejecting_reg::get_string()
  1047. {
  1048.   return itoa(topdiv->get_ejecting());
  1049. }
  1050.  
  1051. class constant_vunits_reg : public reg {
  1052.   vunits *p;
  1053. public:
  1054.   constant_vunits_reg(vunits *);
  1055.   const char *get_string();
  1056. };
  1057.  
  1058. constant_vunits_reg::constant_vunits_reg(vunits *q) : p(q)
  1059. {
  1060. }
  1061.  
  1062. const char *constant_vunits_reg::get_string()
  1063. {
  1064.   return itoa(p->to_units());
  1065. }
  1066.  
  1067. void init_div_requests()
  1068. {
  1069.   init_request("wh", when_request);
  1070.   init_request("ch", change_trap);
  1071.   init_request("pl", page_length);
  1072.   init_request("po", page_offset);
  1073.   init_request("rs", restore_spacing);
  1074.   init_request("ns", no_space);
  1075.   init_request("sp", space_request);
  1076.   init_request("di", divert);
  1077.   init_request("da", divert_append);
  1078.   init_request("bp", begin_page);
  1079.   init_request("ne", need_space);
  1080.   init_request("pn", page_number);
  1081.   init_request("dt", diversion_trap);
  1082.   init_request("rt", return_request);
  1083.   init_request("mk", mark);
  1084.   init_request("sv", save_vertical_space);
  1085.   init_request("os", output_saved_vertical_space);
  1086.   init_request("fl", flush_output);
  1087.   init_request("vpt", vertical_position_traps);
  1088.   init_request("ptr", print_traps);
  1089.   number_reg_dictionary.define(".a",
  1090.                new constant_int_reg(&last_post_line_extra_space));
  1091.   number_reg_dictionary.define(".z", new diversion_name_reg);
  1092.   number_reg_dictionary.define(".o", new page_offset_reg);
  1093.   number_reg_dictionary.define(".p", new page_length_reg);
  1094.   number_reg_dictionary.define(".d", new vertical_position_reg);
  1095.   number_reg_dictionary.define(".h", new high_water_mark_reg);
  1096.   number_reg_dictionary.define(".t", new distance_to_next_trap_reg);
  1097.   number_reg_dictionary.define("dl", new variable_reg(&dl_reg_contents));
  1098.   number_reg_dictionary.define("dn", new variable_reg(&dn_reg_contents));
  1099.   number_reg_dictionary.define("nl", new variable_reg(&nl_reg_contents));
  1100.   number_reg_dictionary.define(".vpt", 
  1101.                new constant_int_reg(&vertical_position_traps_flag));
  1102.   number_reg_dictionary.define("%", new page_number_reg);
  1103.   number_reg_dictionary.define(".pn", new next_page_number_reg);
  1104.   number_reg_dictionary.define(".trunc",
  1105.                    new constant_vunits_reg(&truncated_space));
  1106.   number_reg_dictionary.define(".ne",
  1107.                    new constant_vunits_reg(&needed_space));
  1108.   number_reg_dictionary.define(".pe", new page_ejecting_reg);
  1109. }
  1110.